#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Ce module contient une classe permettant de gérer une donne de poker.
"""
__auteur__ = ""
__coequipiers__ = None
__date__ = ""

import JeuDeCarte

class Donne(JeuDeCarte.Donne):
    """ Cette classe encapsule une donne de poker, capable de se comparer
    avec une autre donne et de déterminer laquelle est supérieure. """
    valeurs = {'2': 1, '3': 2, '4': 3, '5': 4, '6': 5, '7': 6, '8': 7, '9': 8, '10': 9,
               'J': 10, 'Q': 11, 'K': 12, 'A': 13}

    def _valeur(self):
        """ Cette fonction produit un tuple qui détermine la valeur relative
        d'une donne de Poker.

        :returns: un tuple de la forme (s, (v1, v2, v3, v4, v5)), où s correspond 
        à la valeur du type de la donne (carré=17, full=13, brelan=11, double paire=9, 
        paire=7, carte haute=5), et où v1, v2, v3, v4 et v5 sont les valeurs ordonnées 
        des cinq cartes.
        """
        valeurs = tuple(self.valeurs[x.figure] for x in self.cartes)
        comptes = tuple(valeurs.count(x) for x in valeurs)
        valeurs = (b for (a, b) in sorted(zip(comptes, valeurs), reverse=True))
        return sum(comptes), tuple(valeurs)

    def __lt__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.

        :param donne: la donne à comparer avec self.
        :returns: True si self est inférieure à donne; False autrement.
        """
        return self._valeur() < donne._valeur()

    def __le__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.

        :param donne: la donne à comparer avec self.
        :returns: True si self est inférieure ou égale à donne; False autrement.
        """
        return self._valeur() <= donne._valeur()

    def __gt__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.

        :param donne: la donne à comparer avec self.
        :returns: True si self est supérieure à donne; False autrement.
        """
        return self._valeur() > donne._valeur()

    def __ge__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.

        :param donne: la donne à comparer avec self.
        :returns: True si self est supérieure ou égale à donne; False autrement.
        """
        return self._valeur() >= donne._valeur()

    def __eq__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.

        :param donne: la donne à comparer avec self.
        :returns: True si self est égale à donne; False autrement.
        """
        return self._valeur() == donne._valeur()

    def __ne__(self, donne):
        """ Comparer la valeur de self avec celle d'une autre donne.

        :param donne: la donne à comparer avec self.
        :returns: True si self n'est pas égale à donne; False autrement.
        """
        return self._valeur() != donne._valeur()

    def __str__(self):
        """ Convertir en chaîne de caractères.

        :returns: la donne sous la forme d'une séquence ordonnée de cartes.
        """
        valeurs = tuple(self.valeurs[x.figure] for x in self.cartes)
        comptes = (valeurs.count(x) for x in valeurs)
        indices = (c for (a, b, c) in sorted(zip(comptes, valeurs, range(len(self.cartes))),
                                             reverse=True))
        return ''.join(str(self.cartes[i]) for i in indices)

if __name__ == '__main__':
    # programme principal
    print("Ceci est le module Poker; test de 10 donnes aléatoires")
    p = JeuDeCarte.Paquet()
    for i in range(10):
        print('Donnes #{}'.format(i+1))
        d1 = Donne()
        d2 = Donne()
        for i in range(5):
            d1.ajouter(p.tirer().flipper())
            d2.ajouter(p.tirer().flipper())
        if d1 < d2:
            print('{:>24} < {:<24}'.format(d1, d2))
            print('{:>24} < {:<24}'.format(d1._valeur(), d2._valeur()))
        else:
            print('{:>24} ≥ {:<24}'.format(d1, d2))
            print('{:>24} ≥ {:<24}'.format(d1._valeur(), d2._valeur()))
